ടൈപ്പ്സ്ക്രിപ്റ്റ് അഡ്വാൻസ്ഡ് ടൈപ്പുകൾ: ടെംപ്ലേറ്റ് ലിറ്ററൽ, കണ്ടീഷണൽ ടൈപ്പുകളിൽ പ്രാവീണ്യം നേടാം

അന്താരാഷ്ട്ര ഉദാഹരണം: വ്യത്യസ്ത തീയതി ഫോർമാറ്റുകൾ കൈകാര്യം ചെയ്യൽ

ലോകത്തിൻ്റെ വിവിധ ഭാഗങ്ങളിൽ വ്യത്യസ്ത തീയതി ഫോർമാറ്റുകളാണ് ഉപയോഗിക്കുന്നത്. ഈ വ്യത്യാസങ്ങൾ കൈകാര്യം ചെയ്യാൻ നിങ്ങൾക്ക് കണ്ടീഷണൽ ടൈപ്പുകൾ ഉപയോഗിക്കാം.

type DateFormat = "YYYY-MM-DD" | "MM/DD/YYYY" | "DD.MM.YYYY";

type ParseDate = T extends "YYYY-MM-DD"
  ? { year: number; month: number; day: number; format: "YYYY-MM-DD" }
  : T extends "MM/DD/YYYY"
  ? { month: number; day: number; year: number; format: "MM/DD/YYYY" }
  : T extends "DD.MM.YYYY"
  ? { day: number; month: number; year: number; format: "DD.MM.YYYY" }
  : never;


function parseDate(dateString: string, format: T): ParseDate {
  // (Implementation would handle different date formats)
  if (format === "YYYY-MM-DD") {
    const [year, month, day] = dateString.split("-").map(Number);
    return { year, month, day, format } as ParseDate;
  } else if (format === "MM/DD/YYYY") {
    const [month, day, year] = dateString.split("/").map(Number);
    return { month, day, year, format } as ParseDate;
  } else if (format === "DD.MM.YYYY") {
    const [day, month, year] = dateString.split(".").map(Number);
    return { day, month, year, format } as ParseDate;
  } else {
    throw new Error("Invalid date format");
  }
}

const parsedDateISO = parseDate("2023-10-27", "YYYY-MM-DD"); // Type: { year: number; month: number; day: number; format: "YYYY-MM-DD"; }
const parsedDateUS = parseDate("10/27/2023", "MM/DD/YYYY"); // Type: { month: number; day: number; year: number; format: "MM/DD/YYYY"; }
const parsedDateEU = parseDate("27.10.2023", "DD.MM.YYYY"); // Type: { day: number; month: number; year: number; format: "DD.MM.YYYY"; }


console.log(parsedDateISO.year); // Access the year knowing it will be there

നിർദ്ദിഷ്ട തീയതി ഫോർമാറ്റിനെ അടിസ്ഥാനമാക്കി വ്യത്യസ്ത ഡേറ്റ് പാഴ്‌സിംഗ് ഫംഗ്ഷനുകൾ നിർവചിക്കുന്നതിന് ഈ ഉദാഹരണം കണ്ടീഷണൽ ടൈപ്പുകൾ ഉപയോഗിക്കുന്നു. നൽകിയിട്ടുള്ള ഫോർമാറ്റിനെ അടിസ്ഥാനമാക്കി, തിരികെ ലഭിക്കുന്ന ഒബ്ജക്റ്റിന് ശരിയായ പ്രോപ്പർട്ടികൾ ഉണ്ടെന്ന് ParseDate എന്ന ടൈപ്പ് ഉറപ്പാക്കുന്നു.

ടെംപ്ലേറ്റ് ലിറ്ററൽ, കണ്ടീഷണൽ ടൈപ്പുകൾ സംയോജിപ്പിക്കൽ

ടെംപ്ലേറ്റ് ലിറ്ററൽ ടൈപ്പുകളും കണ്ടീഷണൽ ടൈപ്പുകളും സംയോജിപ്പിക്കുമ്പോഴാണ് യഥാർത്ഥ ശക്തി വരുന്നത്. ഇത് അവിശ്വസനീയമാംവിധം ശക്തമായ ടൈപ്പ് മാനിപ്പുലേഷനുകൾക്ക് വഴിയൊരുക്കുന്നു.

type EventName = `on${Capitalize}`;

type ExtractEventPayload = T extends EventName
  ? { type: T; payload: any }  // Simplified for demonstration
  : never;


type ClickEvent = EventName<"click">;  // "onClick"
type MouseOverEvent = EventName<"mouseOver">;  // "onMouseOver"


//Example function that takes a type
function processEvent(event: T): ExtractEventPayload {
    //In a real implementation, we would actually dispatch the event.
    console.log(`Processing event ${event}`);

    //In a real implementation, the payload would be based on event type.
    return { type: event, payload: {} } as ExtractEventPayload;
}

//Note that the return types are very specific:
const clickEvent = processEvent("onClick");  //  { type: "onClick"; payload: any; }
const mouseOverEvent = processEvent("onMouseOver"); //  { type: "onMouseOver"; payload: any; }

//If you use other strings, you get never:
// const someOtherEvent = processEvent("someOtherEvent"); // Type is `never`

മികച്ച രീതികളും പരിഗണനകളും

• ലളിതമായി സൂക്ഷിക്കുക: ശക്തമാണെങ്കിലും, ഈ നൂതന ടൈപ്പുകൾ വേഗത്തിൽ സങ്കീർണ്ണമാകും. വ്യക്തതയ്ക്കും പരിപാലനക്ഷമതയ്ക്കും വേണ്ടി ശ്രമിക്കുക.
• പൂർണ്ണമായി പരിശോധിക്കുക: സമഗ്രമായ യൂണിറ്റ് ടെസ്റ്റുകൾ എഴുതി നിങ്ങളുടെ ടൈപ്പ് ഡെഫനിഷനുകൾ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കുക.
• നിങ്ങളുടെ കോഡ് ഡോക്യുമെൻ്റ് ചെയ്യുക: കോഡ് വായനാക്ഷമത മെച്ചപ്പെടുത്തുന്നതിന് നിങ്ങളുടെ നൂതന ടൈപ്പുകളുടെ ഉദ്ദേശ്യവും പ്രവർത്തനവും വ്യക്തമായി രേഖപ്പെടുത്തുക.
• പ്രകടനം പരിഗണിക്കുക: നൂതന ടൈപ്പുകളുടെ അമിതമായ ഉപയോഗം കംപൈലേഷൻ സമയത്തെ ബാധിക്കും. നിങ്ങളുടെ കോഡ് പ്രൊഫൈൽ ചെയ്യുകയും ആവശ്യമുള്ളിടത്ത് ഒപ്റ്റിമൈസ് ചെയ്യുകയും ചെയ്യുക.